#!/usr/bin/env python3
"""
Image Analyzer 统一启动器
支持所有处理模式：标准模式、快速模式、弹性模式
"""

import argparse
import os
import sys
from pathlib import Path
from typing import List, Optional

# 添加core目录到Python路径
sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'core'))

from core.config_manager_json import get_config
from core.file_manager import FileManager
from core.performance_monitor import PerformanceMonitor
from core.image_processor import ImageProcessor
from core.image_processor_fast import FastImageProcessor
from core.resilient_processor import ResilientImageProcessor


class ImageAnalyzerUnified:
    """统一图片分析器"""
    
    def __init__(self):
        """初始化分析器"""
        self.config_manager = get_config()
        self.file_manager = None
        self.processor = None
        self.monitor = None
    
    def setup_components(self, args):
        """根据参数设置组件"""
        # 更新配置
        if args.ollama_host:
            self.config_manager.set('ollama.host', args.ollama_host)
        if args.ollama_port:
            self.config_manager.set('ollama.port', args.ollama_port)
        if args.model:
            self.config_manager.set('ollama.model', args.model)
        
        # 设置文件管理
        file_config = self.config_manager.get_file_management_config()
        if args.separate_files:
            file_config['separate_files'] = True
        if args.text_output_dir:
            file_config['text_output_dir'] = args.text_output_dir
        
        self.file_manager = FileManager(file_config)
        
        # 设置性能监控
        if args.monitor or self.config_manager.get('processing.enable_monitoring'):
            self.monitor = PerformanceMonitor()
        
        # 选择处理器
        mode = args.mode or self.config_manager.get('processing.mode')
        
        if mode == 'fast':
            self.processor = FastImageProcessor(
                self.config_manager.get_ollama_config(),
                self.config_manager.get_performance_config()
            )
        elif mode == 'resilient':
            self.processor = ResilientImageProcessor(
                self.config_manager.get_ollama_config(),
                self.config_manager.get_performance_config()
            )
        else:
            self.processor = ImageProcessor(
                self.config_manager.get_ollama_config(),
                self.config_manager.get_performance_config()
            )
    
    def analyze_images(self, image_paths: List[str]) -> bool:
        """
        分析图片列表
        
        Args:
            image_paths: 图片路径列表
            
        Returns:
            bool: 处理是否成功
        """
        if not image_paths:
            print("错误: 没有找到图片文件")
            return False
        
        print(f"开始处理 {len(image_paths)} 张图片...")
        print(self.config_manager.get_config_summary())
        print("-" * 50)
        
        # 开始性能监控
        if self.monitor:
            self.monitor.start_monitoring()
        
        try:
            success_count = 0
            total_count = len(image_paths)
            
            for i, image_path in enumerate(image_paths, 1):
                try:
                    print(f"[{i}/{total_count}] 处理: {Path(image_path).name}")
                    
                    # 生成描述
                    description = self.processor.generate_description(image_path)
                    
                    if description:
                        # 保存描述
                        output_path = self.file_manager.save_description(
                            image_path, description
                        )
                        print(f"    ✓ 描述已保存: {output_path}")
                        success_count += 1
                    else:
                        print(f"    ✗ 生成描述失败")
                
                except Exception as e:
                    print(f"    ✗ 处理失败: {e}")
            
            # 显示结果统计
            print("-" * 50)
            print(f"处理完成: {success_count}/{total_count} 张图片成功")
            
            # 显示性能统计
            if self.monitor:
                stats = self.monitor.get_statistics()
                print(f"总耗时: {stats.get('total_time', 0):.2f}秒")
                print(f"平均耗时: {stats.get('avg_time', 0):.2f}秒/张")
            
            return success_count > 0
            
        except KeyboardInterrupt:
            print("\n用户中断处理")
            return False
        except Exception as e:
            print(f"处理过程中发生错误: {e}")
            return False
        finally:
            # 停止性能监控
            if self.monitor:
                self.monitor.stop_monitoring()
    
    def analyze_directory(self, directory: str, recursive: bool = False) -> bool:
        """
        分析目录中的图片
        
        Args:
            directory: 目录路径
            recursive: 是否递归处理子目录
            
        Returns:
            bool: 处理是否成功
        """
        print(f"扫描目录: {directory}")
        
        # 获取图片文件列表
        image_extensions = {'.jpg', '.jpeg', '.png', '.bmp', '.gif', '.tiff', '.webp'}
        image_paths = []
        
        if recursive:
            for root, dirs, files in os.walk(directory):
                for file in files:
                    if Path(file).suffix.lower() in image_extensions:
                        image_paths.append(os.path.join(root, file))
        else:
            for file in os.listdir(directory):
                file_path = os.path.join(directory, file)
                if (os.path.isfile(file_path) and 
                    Path(file).suffix.lower() in image_extensions):
                    image_paths.append(file_path)
        
        if not image_paths:
            print("未找到图片文件")
            return False
        
        return self.analyze_images(image_paths)


def create_parser() -> argparse.ArgumentParser:
    """创建命令行参数解析器"""
    parser = argparse.ArgumentParser(
        description='Image Analyzer - 智能图片描述生成工具',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
使用示例:
  %(prog)s ./photos                    # 处理photos目录中的图片
  %(prog)s ./photos --recursive        # 递归处理子目录
  %(prog)s image.jpg                # 处理单张图片
  %(prog)s ./photos --fast             # 使用快速模式
  %(prog)s ./photos --separate-files   # 文件分离存储
  %(prog)s ./photos --monitor          # 启用性能监控
        """
    )
    
    # 基本参数
    parser.add_argument('input', help='输入路径（图片文件或目录）')
    
    # 模式选择
    mode_group = parser.add_mutually_exclusive_group()
    mode_group.add_argument('--fast', action='store_true',
                           help='使用快速模式（5-10倍性能提升）')
    mode_group.add_argument('--resilient', action='store_true',
                           help='使用弹性模式（高可靠性）')
    mode_group.add_argument('--mode', choices=['standard', 'fast', 'resilient'],
                           help='指定处理模式')
    
    # Ollama配置
    parser.add_argument('--ollama-host', default=None,
                       help='Ollama服务器地址（默认: localhost）')
    parser.add_argument('--ollama-port', type=int, default=None,
                       help='Ollama服务器端口（默认: 11434）')
    parser.add_argument('--model', default=None,
                       help='使用的模型（默认: qwen2.5-vl:7b）')
    
    # 文件管理
    parser.add_argument('--separate-files', action='store_true',
                       help='启用文件分离存储')
    parser.add_argument('--text-output-dir', default=None,
                       help='文本文件输出目录（默认: descriptions）')
    parser.add_argument('--overwrite', action='store_true',
                       help='覆盖已存在的描述文件')
    
    # 处理选项
    parser.add_argument('--recursive', '-r', action='store_true',
                       help='递归处理子目录')
    parser.add_argument('--monitor', action='store_true',
                       help='启用性能监控')
    parser.add_argument('--batch-size', type=int, default=None,
                       help='批处理大小')
    parser.add_argument('--max-workers', type=int, default=None,
                       help='最大工作线程数')
    
    # 配置选项
    parser.add_argument('--config', default='settings.json',
                       help='配置文件路径（默认: settings.json）')
    parser.add_argument('--preset', choices=['high_performance', 'balanced', 'reliable'],
                       help='使用预设配置')
    
    # 信息选项
    parser.add_argument('--show-config', action='store_true',
                       help='显示当前配置并退出')
    parser.add_argument('--version', action='version', version='%(prog)s 2.0.0')
    
    return parser


def apply_preset(config_manager, preset: str):
    """应用预设配置"""
    if preset == 'high_performance':
        config_manager.update_processing_config(
            mode='fast',
            batch_size=20,
            max_workers=8,
            enable_monitoring=False
        )
        config_manager.update_performance_config(
            enable_fast_mode=True,
            parallel_processing=True,
            memory_limit_mb=2048
        )
    elif preset == 'balanced':
        config_manager.update_processing_config(
            mode='standard',
            batch_size=10,
            max_workers=4,
            enable_monitoring=True
        )
        config_manager.update_performance_config(
            enable_fast_mode=False,
            parallel_processing=True,
            memory_limit_mb=1024
        )
    elif preset == 'reliable':
        config_manager.update_processing_config(
            mode='resilient',
            batch_size=5,
            max_workers=2,
            enable_monitoring=True
        )
        config_manager.update_performance_config(
            enable_fast_mode=False,
            parallel_processing=False,
            memory_limit_mb=512
        )


def main():
    """主函数"""
    parser = create_parser()
    args = parser.parse_args()
    
    # 检查输入路径
    input_path = args.input
    if not os.path.exists(input_path):
        print(f"错误: 输入路径不存在: {input_path}")
        sys.exit(1)
    
    # 创建分析器
    analyzer = ImageAnalyzerUnified()
    
    # 加载配置
    if args.config != 'settings.json':
        # 使用自定义配置文件
        analyzer.config_manager.config_file = Path(args.config)
        analyzer.config_manager.load_config()
    
    # 应用预设
    if args.preset:
        apply_preset(analyzer.config_manager, args.preset)
    
    # 设置组件
    analyzer.setup_components(args)
    
    # 显示配置
    if args.show_config:
        print("当前配置:")
        print(analyzer.config_manager.get_config_summary())
        sys.exit(0)
    
    # 验证配置
    if not analyzer.config_manager.validate_config():
        print("错误: 配置无效")
        sys.exit(1)
    
    # 处理输入
    if os.path.isfile(input_path):
        # 单个文件
        success = analyzer.analyze_images([input_path])
    elif os.path.isdir(input_path):
        # 目录
        success = analyzer.analyze_directory(input_path, args.recursive)
    else:
        print(f"错误: 不支持的输入类型: {input_path}")
        sys.exit(1)
    
    sys.exit(0 if success else 1)


if __name__ == '__main__':
    main()